/*
 * utilidad.cpp
 *
 */

#include "../utiles/Utilidad.h"



Utilidad::Utilidad(){

	c = ' ';
}

void Utilidad::error_terminar(){

	cout << "error al ingresar comandos"<<endl;
	cin >> c;

}

string Utilidad::downcase(string palabra){

	string::iterator iter;

	for( iter = palabra.begin(); iter != palabra.end(); ++iter ) {
			*iter = tolower(*iter);
	}

	return palabra;

}

string Utilidad::quitar_acentos(string palabra){


    map<string,string> caracteres;
    map<string,string>::iterator it;
    string caracter;
    string caracter_reemplazo;
    size_t found;

	caracteres.insert (pair<string,string>("á","a") );
	caracteres.insert (pair<string,string>("é","e") );
	caracteres.insert (pair<string,string>("í","i") );
	caracteres.insert (pair<string,string>("ó","o") );
	caracteres.insert (pair<string,string>("ú","u") );
	//caracteres.insert (pair<string,string>("ñ","n") );

	for (it= caracteres.begin(); it != caracteres.end(); it++)
	{
	    caracter=(it->first);

//	    cout << caracter << endl;
	    found = palabra.find(caracter);

	    if(found != string::npos){
        caracter_reemplazo=(it->second);

//        cout << caracter_reemplazo << endl;
        palabra.erase(found,caracter.length());
        palabra.replace(found,0,caracter_reemplazo,0,1);
	    //found = palabra.find(caracter,found+1);
	    }
	}

     return palabra;
}


string Utilidad::quitar_invalidos(string palabra){

    size_t found;

    found = palabra.find_first_of("/\",.;:?¿!¡_-+=()~{}[]^*`´&%$#|¬¨<>\\");
    while (found!=string::npos)
    {
    palabra.erase(found,1);
    found=palabra.find_first_of("/\",.;:?¿!¡_-+=()~{}[]^*`´&%$#|¬¨<>\\",found);
    }

    return palabra;

}

string Utilidad::quitar_puntosYcomas(string palabra){

	string palabraCopia;
	unsigned int found = palabra.find_first_of(",.;");
	if(found < 100)
    	palabraCopia = palabra.erase(found,1);
	else
		palabraCopia = palabra;

	return palabraCopia;
}

string Utilidad::int_to_string(int valor){

	stringstream ss;
	ss << valor;
	return ss.str();

}


/* retorna verdadero si ID_doc esta en la lista, falso si no esta
 *
 */
bool Utilidad::estaEnListaDeRelevancias(vector<RegistroRelevanciaDeDocumento> &vectorR, int id_doc){
	int tam = vectorR.size();
	int i= 0;
	while(i < tam ){

		if(vectorR[i].getId_Doc() == id_doc)
			return true;

		i++;
	}
	return false;
}

/* retorna el registroIndice que tiene el termino ó un regIndice vacio en caso de no estar el termino
 *
 */
//RegistroIndice Utilidad::obtenerRegistroQueTieneElTermino(list<RegistroIndice> lri, string t){
//	list<RegistroIndice>::iterator iteradorRegistroIndice = lri.begin();
//	RegistroIndice *regIndiceVacio = new RegistroIndice();
//	bool encontreTermino = false;
//
//	while((iteradorRegistroIndice != lri.end()) & (!encontreTermino)){
//
//		if((*iteradorRegistroIndice).obtenerPalabra() == t)
//			return (*iteradorRegistroIndice);
//
//		iteradorRegistroIndice++;
//	}
//	return (*regIndiceVacio);
//}

/* ordena el vertor pasado por referencia, dejandolo ordenado por relevancia de documento
 *
 */
void Utilidad::ordenarPorShellSort(vector<RegistroRelevanciaDeDocumento> &v_reg_rel){

   //el primer salto o gap (representado por la variable k)
   //es la mitad de la longitud del array
   int k = v_reg_rel.size() / 2;
   //este primer bucle nos mantendrá dentro del algoritmo
   //mientras el salto sea mayor o igual que 1. Antes de
   //cada iteración dividimos el salto o gap (k) entre 2
   while (k >= 1)
   {
     //este segundo bucle es el resultado de compactar los
     //dos bucles de la version anterior del algoritmo.
     //Logramos lo mismo (que i valga desde k hasta A.Lenght-1
     //pero en otra secuencia.
     //Nos hemos quitado una variable de en medio: subarray
	   int tam = v_reg_rel.size();
     for (int i=k; i < tam ; i++)
     {
       RegistroRelevanciaDeDocumento a = v_reg_rel[i]; //tomamos el elemento i-ésimo
       int j = i - k; //apuntamos al anterior en el subarray
       //Con este bucle desplazamos elementos en el subarray
       //hasta encontrar la posición que le corresponde
       //al elemento i-ésimo que tenemos guardado en v
       //Es como el bucle interior de la inserción directa
       //pero adaptado para moverse por un subarray con
       //con salto k
       while (j >= 0 && v_reg_rel[j].getRelevancia() > a.getRelevancia())
       {
         v_reg_rel[j + k] = v_reg_rel[j];
         j -= k;
       }
       v_reg_rel[j + k] = a;
     } //fin for
   k /= 2;
   } //fin while
} //ShellSort


/*
int utilidad::procesar_comandos(int cantidad_argumentos,char** palabras, booquerio * b){

	if (strlen(palabras[1]) == 2) {//no comparo el nombre porque se puede compilar de cualquier manera.
			if (*palabras[1] == '-') {
				if (strcmp(palabras[2], " ") == 0) {
					this->error_terminar();

				}
				switch (palabras[1][2]) {
				case 'i':
					if (cantidad_argumentos >= 4) {
						this->error_terminar();
					} else {
						b->tomar_texto(archivo);
					}
					;
					break;
				case 'e':
					if (cantidad_argumentos >= 3) {
						util->error_terminar();
					} else {
						b->Procesar_editorial();
					}
					;
					break;
				case 'a':
					if (cantidad_argumentos >= 3) {
						util->error_terminar();
					} else {
						b->Procesar_autor();
					}
					;
					break;
				case 't':
					if (cantidad_argumentos >= 3) {
						util->error_terminar();
					} else {
						b->Procesar_titulo();
					}
					;
					break;
				case 'p':
					if (cantidad_argumentos >= 3) {
						util->error_terminar();
					} else {
						b->Procesar_Palabras();
					}
					;
					break;
				case 'l':
					if (cantidad_argumentos >= 3) {
						util->error_terminar();
					} else {
						b->Lista_archivo_tomados();
					}
					;
					break;
				case 'o':
					if (cantidad_argumentos >= 4) {
						util->error_terminar();
					} else {
						b->Obtener_archivo((int) palabras[2]);
					}
					;
					break;
				case 'q':
					if (cantidad_argumentos >= 4) {
						util->error_terminar();
					} else {
						b->Quitar_archivo((int) palabras[2]);
					}
					;
					break;
				case 'v':
                       if (strlen(palabras[2]) == 2){
                           if ((strcmp(palabras[3], " ") == 0)||(cantidad_argumentos >= 5)) {
    										util->error_terminar();

    						}
                          if (*palabras[2] == '-') {
                                           switch(palabras[2][2]) {
                                                                  case 'e':
                                                                       b->Ver_estructura_editorial(palabras[3]);
                                                                       break;
                                                                  case 'a':
                                                                       b->Ver_estructura_autor(palabras[3]);
                                                                       break;
                                                                  case 't':
                                                                       b->Ver_estructura_titulo(palabras[3]);
                                                                       break;
                                                                  case 'p':
                                                                       b->Ver_estructura_palabra(palabras[3]);
                                                                       break;
                                                                  default:
                                            							util->error_terminar();
                                            							break;
                                                                  }
                                                  }
                                                 }





    return 0;
}
}
}
}
*/
